import { http } from './request.js'
import storage from '@/utils/storage.js'

// 本地购物车存储键名
const LOCAL_CART_KEY = 'local_cart_items'

// 检查用户是否登录
const isUserLoggedIn = () => {
    return !!storage.getToken()
}

// 从本地存储获取购物车数据
const getLocalCart = () => {
    try {
        return uni.getStorageSync(LOCAL_CART_KEY) || { items: [], count: 0 }
    } catch (e) {
        console.error('读取本地购物车失败:', e)
        return { items: [], count: 0 }
    }
}

// 保存购物车数据到本地存储
const saveLocalCart = (cart) => {
    try {
        uni.setStorageSync(LOCAL_CART_KEY, cart)
    } catch (e) {
        console.error('保存本地购物车失败:', e)
    }
}

// 购物车相关API
export const cartApi = {
    // 获取购物车
    getCart() {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.get('/user/cart')
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart()
            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: {
                    items: localCart.items,
                    totalPrice: localCart.items.reduce((sum, item) => sum + item.price * item.quantity, 0),
                    selectedCount: localCart.items.filter(item => item.selected).length,
                    totalCount: localCart.items.length
                }
            })
        }
    },

    // 获取购物车商品数量
    getCartCount() {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.get('/user/cart/count')
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart()
            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: localCart.count
            })
        }
    },

    // 添加商品到购物车
    addToCart(data) {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.post('/user/cart/items', data);
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart();
            const { productId, skuId, quantity } = data;

            // 查找是否已存在相同商品
            const existingItemIndex = localCart.items.findIndex(
                item => item.product.id === productId && item.sku.id === skuId
            );

            if (existingItemIndex >= 0) {
                // 已存在，更新数量
                localCart.items[existingItemIndex].quantity += quantity;
            } else {
                // 不存在，添加新项
                // 注意：这里需要从其他地方获取产品和SKU信息
                // 简化起见，这里仅保存基本信息
                localCart.items.push({
                    id: Date.now(), // 临时ID
                    product: { id: productId },
                    sku: { id: skuId },
                    quantity: quantity,
                    selected: true,
                    price: 0 // 这里需要设置实际价格，暂时为0
                });
            }

            // 更新总数量
            localCart.count = localCart.items.reduce((sum, item) => sum + item.quantity, 0);

            // 保存到本地
            saveLocalCart(localCart);

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 更新购物车商品数量
    updateCartItem(itemId, data) {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.put(`/user/cart/items/${itemId}`, data);
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart();
            const itemIndex = localCart.items.findIndex(item => item.id === itemId);

            if (itemIndex >= 0) {
                localCart.items[itemIndex].quantity = data.quantity;
                // 更新总数量
                localCart.count = localCart.items.reduce((sum, item) => sum + item.quantity, 0);
                saveLocalCart(localCart);
            }

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 删除购物车商品
    deleteCartItem(itemId) {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.delete(`/user/cart/items/${itemId}`);
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart();
            localCart.items = localCart.items.filter(item => item.id !== itemId);
            // 更新总数量
            localCart.count = localCart.items.reduce((sum, item) => sum + item.quantity, 0);
            saveLocalCart(localCart);

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 清空购物车
    clearCart() {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.delete('/user/cart/items');
        } else {
            // 未登录，使用本地存储
            saveLocalCart({ items: [], count: 0 });

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 批量删除购物车商品
    batchDeleteCartItems(ids) {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.post('/user/cart/items/batch-delete', { ids });
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart();
            localCart.items = localCart.items.filter(item => !ids.includes(item.id));
            // 更新总数量
            localCart.count = localCart.items.reduce((sum, item) => sum + item.quantity, 0);
            saveLocalCart(localCart);

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 选择/取消选择购物车商品
    toggleCartItemSelection(itemId, selected) {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.put(`/user/cart/items/${itemId}/selection`, { selected });
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart();
            const itemIndex = localCart.items.findIndex(item => item.id === itemId);

            if (itemIndex >= 0) {
                localCart.items[itemIndex].selected = selected;
                saveLocalCart(localCart);
            }

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 全选/取消全选购物车商品
    toggleAllCartItemsSelection(selected) {
        if (isUserLoggedIn()) {
            // 已登录，使用后端API
            return http.put('/user/cart/items/selection-all', { selected });
        } else {
            // 未登录，使用本地存储
            const localCart = getLocalCart();
            localCart.items.forEach(item => {
                item.selected = selected;
            });
            saveLocalCart(localCart);

            return Promise.resolve({
                code: 200,
                msg: 'success',
                data: true
            });
        }
    },

    // 同步本地购物车到服务器（登录后调用）
    syncLocalCartToServer() {
        const localCart = getLocalCart();

        if (localCart.items.length === 0) {
            return Promise.resolve({
                code: 200,
                msg: 'No items to sync',
                data: true
            });
        }

        // 这里可以实现批量添加到服务器的逻辑
        // 为简化，这里只是示例，实际应该调用后端批量添加接口
        const promises = localCart.items.map(item => {
            return http.post('/user/cart/items', {
                productId: item.product.id,
                skuId: item.sku.id,
                quantity: item.quantity
            });
        });

        return Promise.all(promises)
            .then(() => {
                // 清空本地购物车
                saveLocalCart({ items: [], count: 0 });
                return {
                    code: 200,
                    msg: 'Sync successful',
                    data: true
                };
            })
            .catch(error => {
                console.error('同步购物车失败:', error);
                return {
                    code: 500,
                    msg: 'Sync failed',
                    data: false
                };
            });
    }
}; 